Web Element Operations in Selenium with Python

Web Element Operations are the actions performed on HTML elements of a web application using Selenium WebDriver. In Selenium automation, a web element can be a text box, button, checkbox, radio button, link, dropdown, image, label, table row, form field, or any other HTML element that Selenium can identify and interact with.

Selenium provides the WebElement interface for interacting with elements after they have been located. Common operations include clicking elements, entering text, clearing fields, reading text and attributes, checking visibility and enabled state, handling selections, finding child elements, and performing advanced interactions.

Course Resource: Selenium Training | Register for Course Demo

1. What is a Web Element?

A Web Element is an individual HTML element present on a web page. Selenium represents a located HTML element as a WebElement object in Python.

For example, the following HTML contains several web elements:

<input id="username" type="text">

<input id="password" type="password">
<button id="login">Login</button>
<a href="/home">Home</a>

Selenium can locate these elements and perform operations on them.

2. Why are Web Element Operations Important?

Web Element Operations are the foundation of browser automation. A Selenium script normally locates an element first and then performs one or more operations on that element.

• Enter username and password.
• Click login and submit buttons.
• Clear existing input values.
• Read visible text.
• Read HTML attributes.
• Check whether an element is visible.
• Check whether an element is enabled.
• Check whether a checkbox or radio button is selected.
• Interact with links.
• Work with multiple elements.
• Find child elements inside a parent element.
• Perform keyboard operations.
• Perform mouse operations.
• Validate web page behavior.

3. Web Element Operation Flow

Open Browser

      |
      v
Open Web Application
      |
      v
Locate Web Element
      |
      v
Get WebElement Object
      |
      v
Perform Operation
      |
      v
Read / Validate Result
      |
      v
Continue Test
      |
      v
Close Browser

4. Locating a Web Element

Before performing an operation, Selenium must locate the required element. The find_element() method is commonly used for locating a single element.

from selenium import webdriver

from selenium.webdriver.common.by import By
 
driver = webdriver.Chrome()
driver.get("https://example.com")
 
username = driver.find_element(By.ID, "username")

Here, username is a Selenium WebElement object that represents the located HTML element.

5. Common Locator Strategies

6. Creating a WebElement Object

username = driver.find_element(By.ID, "username")

print(username)

The returned object provides methods and properties that allow the test to interact with and inspect the element.

7. click() Operation

The click() method is used to click a web element. It is commonly used with buttons, links, checkboxes, radio buttons, menu items, and other clickable controls.

login_button = driver.find_element(By.ID, "login")

login_button.click()

Selenium's element interaction APIs are designed to perform the action against the current browsing context and check whether the element is interactable before carrying out the operation. :contentReference[oaicite:0]{index=0}

8. Clicking a Link

home_link = driver.find_element(By.LINK_TEXT, "Home")

home_link.click()

CSS Selector can also be used:

home_link = driver.find_element(

    By.CSS_SELECTOR,
    "a.home-link"
)
home_link.click()

9. send_keys() Operation

The send_keys() method simulates typing into an element. It is mainly used with input fields, textareas, content-editable elements, and other keyboard-interactable elements. :contentReference[oaicite:1]{index=1}

username = driver.find_element(By.ID, "username")

username.send_keys("admin")

10. Entering Password

password = driver.find_element(By.ID, "password")

password.send_keys("admin123")

In real automation projects, credentials should be stored securely instead of hardcoding sensitive passwords in test scripts.

11. Clearing an Input Field

The clear() method clears the current value of an editable text field.

search_box = driver.find_element(By.NAME, "q")

search_box.clear()

The operation is intended for editable/resettable text-entry elements such as suitable input fields and textareas. :contentReference[oaicite:2]{index=2}

12. Combining clear() and send_keys()

A common pattern is to clear an existing value and then enter new test data.

search_box = driver.find_element(By.NAME, "q")

search_box.clear()
search_box.send_keys("Selenium Python")

13. Reading Element Text

The text property is used to retrieve the rendered text associated with an element.

message = driver.find_element(By.ID, "message")

print(message.text)

Selenium documents the WebElement text property as the text of the element. :contentReference[oaicite:3]{index=3}

14. Reading Button Text

button = driver.find_element(By.ID, "login")

print("Button Text:", button.text)

This can be useful when validating that a button contains the expected visible label.

15. get_attribute()

The get_attribute() method retrieves the current value of an element attribute or property.

username = driver.find_element(By.ID, "username")

 
value = username.get_attribute("value")
placeholder = username.get_attribute("placeholder")
class_name = username.get_attribute("class")
 
print(value)
print(placeholder)
print(class_name)

In Selenium Python, get_attribute() can return a property value when one exists and otherwise fall back to the corresponding attribute. For exact DOM attributes, Selenium also provides get_dom_attribute(), while get_property() retrieves a property directly. :contentReference[oaicite:4]{index=4}

16. get_dom_attribute()

get_dom_attribute() retrieves the HTML attribute value declared in the DOM markup.

button = driver.find_element(By.ID, "login")

 
value = button.get_dom_attribute("class")
print(value)

This is useful when the exact HTML attribute value is required rather than a reflected property. :contentReference[oaicite:5]{index=5}

17. get_property()

The get_property() method retrieves a DOM property from an element.

checkbox = driver.find_element(By.ID, "remember")

 
checked = checkbox.get_property("checked")
print(checked)

Properties and HTML attributes can differ, especially for dynamic form controls. Selenium provides separate APIs for properties and DOM attributes. :contentReference[oaicite:6]{index=6}

18. is_displayed()

The is_displayed() method checks whether an element is displayed to the user.

message = driver.find_element(By.ID, "message")

 
if message.is_displayed():
    print("Message is visible")
else:
    print("Message is not visible")

The method returns a Boolean value: True when Selenium considers the element displayed and False otherwise. :contentReference[oaicite:7]{index=7}

19. is_enabled()

The is_enabled() method checks whether an element is enabled.

login_button = driver.find_element(By.ID, "login")

 
if login_button.is_enabled():
    print("Login button is enabled")
else:
    print("Login button is disabled")

This is particularly useful for buttons, input fields, and controls that may be disabled until certain conditions are satisfied. :contentReference[oaicite:8]{index=8}

20. is_selected()

The is_selected() method checks whether an element is currently selected. It is commonly used with checkboxes, radio buttons, and options in select elements. :contentReference[oaicite:9]{index=9}

remember = driver.find_element(By.ID, "remember")

 
if remember.is_selected():
    print("Checkbox is selected")
else:
    print("Checkbox is not selected")

21. Working with Checkboxes

Checkboxes allow users to select or deselect one or more options.

checkbox = driver.find_element(By.ID, "terms")

 
if not checkbox.is_selected():
    checkbox.click()

This pattern avoids clicking a checkbox unnecessarily when it is already selected.

22. Unchecking a Checkbox

checkbox = driver.find_element(By.ID, "newsletter")

 
if checkbox.is_selected():
    checkbox.click()

The script checks the current state before changing it.

23. Working with Radio Buttons

Radio buttons normally allow the user to select one option from a group.

male = driver.find_element(By.ID, "male")

 
if not male.is_selected():
    male.click()

24. Working with Input Fields

Input fields are among the most frequently used elements in Selenium automation.

first_name = driver.find_element(By.ID, "firstName")

last_name = driver.find_element(By.ID, "lastName")
email = driver.find_element(By.ID, "email")
 
first_name.send_keys("John")
last_name.send_keys("Doe")
email.send_keys("[email protected]")

25. Working with Textarea

A textarea can be handled similarly to a text input.

message = driver.find_element(By.ID, "message")

message.clear()
message.send_keys("This is a Selenium test message.")

26. Reading Input Value

The visible text of an input element is normally stored in its value property rather than returned by element.text.

username = driver.find_element(By.ID, "username")

username.send_keys("admin")
 
value = username.get_attribute("value")
print("Entered Value:", value)

27. Working with Links

Links are commonly represented by the HTML <a> element.

link = driver.find_element(By.LINK_TEXT, "About Us")

 
print("Link Text:", link.text)
print("Link URL:", link.get_attribute("href"))
 
link.click()

28. Reading the href Attribute

link = driver.find_element(By.CSS_SELECTOR, "a.home")

 
url = link.get_attribute("href")
 
print("Destination:", url)

This can be useful when validating navigation targets.

29. Reading the Class Attribute

element = driver.find_element(By.ID, "login")

 
class_name = element.get_attribute("class")
 
print("Class:", class_name)

30. Reading the ID Attribute

element = driver.find_element(By.CSS_SELECTOR, "button.login")

 
element_id = element.get_attribute("id")
 
print("ID:", element_id)

31. Getting the Tag Name

The tag_name property returns the HTML tag name of the WebElement.

element = driver.find_element(By.ID, "username")

 
print("Tag:", element.tag_name)

Selenium provides the tag name as one of the element information properties. :contentReference[oaicite:10]{index=10}

32. Checking Element State

Before interacting with an element, automation scripts often need to determine its current state.

33. Finding Multiple Web Elements

When multiple matching elements are required, Selenium provides find_elements().

products = driver.find_elements(

    By.CLASS_NAME,
    "product"
)
 
print("Products:", len(products))

The plural method returns a collection of matching elements; if there are no matches, the result is an empty list. :contentReference[oaicite:11]{index=11}

34. Performing Operations on Multiple Elements

products = driver.find_elements(

    By.CSS_SELECTOR,
    ".product-card"
)
 
for product in products:
    print(product.text)

Python loops can be combined with Selenium WebElements to process lists of page elements.

35. Finding Child Elements

A WebElement can be used as the search context for finding elements inside that element.

form = driver.find_element(By.ID, "login-form")

 
inputs = form.find_elements(
    By.TAG_NAME,
    "input"
)
 
for field in inputs:
    print(field.get_attribute("name"))

This is useful when a page contains repeated components and you want to search only within a specific parent container. Selenium supports finding child elements from a WebElement context. :contentReference[oaicite:12]{index=12}

36. Finding a Single Child Element

form = driver.find_element(By.ID, "login-form")

 
username = form.find_element(
    By.ID,
    "username"
)
 
username.send_keys("admin")

37. Using XPath with Child Elements

form = driver.find_element(By.ID, "login-form")

 
field = form.find_element(
    By.XPATH,
    ".//input[@name='username']"
)
 
field.send_keys("admin")

Using .// with XPath limits the search to descendants of the current WebElement context.

38. Keyboard Operations with Web Elements

The Keys class can be combined with send_keys() for keyboard actions.

from selenium.webdriver.common.keys import Keys

 
search_box = driver.find_element(By.NAME, "q")
 
search_box.send_keys("Selenium")
search_box.send_keys(Keys.ENTER)

39. Using CTRL+A and BACKSPACE

from selenium.webdriver.common.keys import Keys

 
username = driver.find_element(By.ID, "username")
 
username.send_keys(Keys.CONTROL, "a")
username.send_keys(Keys.BACKSPACE)
username.send_keys("new_user")

For simple text replacement, clear() is generally the more direct operation when the element supports it.

40. Submitting a Form

Selenium WebElement APIs include submit() for form submission, but Selenium's current interaction guidance recommends clicking the applicable form submission button rather than relying on the older submit behavior. :contentReference[oaicite:13]{index=13}

login_button = driver.find_element(By.ID, "login")

login_button.click()

41. Clicking with Explicit Wait

Dynamic applications may require synchronization before interacting with an element. An explicit wait can wait until the element is clickable.

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC
 
login_button = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.ID, "login"))
)
 
login_button.click()

42. Waiting for Element Visibility

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC
 
username = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located(
        (By.ID, "username")
    )
)
 
username.send_keys("admin")

43. Presence vs Visibility vs Clickability

44. Scrolling to a Web Element

Selenium normally handles scrolling as part of many element interactions, but explicit scrolling can be useful when building custom workflows.

element = driver.find_element(By.ID, "footer")

 
driver.execute_script(
    "arguments[0].scrollIntoView();",
    element
)

45. JavaScript Click on an Element

JavaScript can technically be used to trigger an element click, but it should not normally be the first solution for an ordinary interaction. Prefer Selenium's native click() when the element can be interacted with normally.

element = driver.find_element(By.ID, "submit")

 
driver.execute_script(
    "arguments[0].click();",
    element
)

JavaScript execution can be useful for specialized cases such as application-specific behavior or troubleshooting interaction issues.

46. Getting Element CSS Values

Element information can include computed CSS values when the automation needs to validate presentation-related properties.

element = driver.find_element(By.ID, "message")

 
font_size = element.value_of_css_property("font-size")
display = element.value_of_css_property("display")
 
print("Font Size:", font_size)
print("Display:", display)

For modern Selenium documentation, retrieving CSS values is part of WebElement information APIs. :contentReference[oaicite:14]{index=14}

47. Element Size and Position

Selenium can expose information about an element's position and dimensions.

element = driver.find_element(By.ID, "login")

 
print("Location:", element.location)
print("Size:", element.size)
print("Rectangle:", element.rect)

This information can be useful when diagnosing layout or interaction problems. Selenium documents element size and position as part of element information. :contentReference[oaicite:15]{index=15}

48. Taking a Screenshot of a Web Element

Element-level screenshots can be useful when diagnosing a specific UI component.

element = driver.find_element(By.ID, "login")

 
element.screenshot("login_button.png")

49. Handling Stale Web Elements

A WebElement reference can become stale when the page or DOM changes after the element was located. In such cases, the old reference may no longer represent the current element.

button = driver.find_element(By.ID, "refresh")

 
button.click()
 
# After a DOM refresh or replacement,
# locate the element again.
button = driver.find_element(By.ID, "refresh")

Re-locating an element after a relevant DOM update is a common approach when handling stale element situations.

50. Common Web Element Exceptions

51. Handling NoSuchElementException

from selenium.common.exceptions import NoSuchElementException

 
try:
    element = driver.find_element(By.ID, "username")
    element.send_keys("admin")
except NoSuchElementException:
    print("Username field was not found")

Exception handling should be used to diagnose or recover from appropriate situations rather than hiding genuine automation failures.

52. Handling ElementClickInterceptedException

from selenium.common.exceptions import ElementClickInterceptedException

 
try:
    login_button = driver.find_element(By.ID, "login")
    login_button.click()
except ElementClickInterceptedException:
    print("Another element is blocking the click")

For dynamic pages, first investigate overlays, loading states, visibility, and synchronization rather than immediately forcing a JavaScript click.

53. Web Element Operations on Forms

A typical form automation flow combines multiple WebElement operations.

username = driver.find_element(By.ID, "username")

password = driver.find_element(By.ID, "password")
remember = driver.find_element(By.ID, "remember")
login_button = driver.find_element(By.ID, "login")
 
username.clear()
username.send_keys("admin")
 
password.clear()
password.send_keys("admin123")
 
if not remember.is_selected():
    remember.click()
 
login_button.click()

54. Complete Login Web Element Example

from selenium import webdriver

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
 
driver = webdriver.Chrome()
 
try:
    driver.get("https://example.com/login")
 
    username = WebDriverWait(driver, 10).until(
        EC.visibility_of_element_located(
            (By.ID, "username")
        )
    )
 
    password = driver.find_element(By.ID, "password")
 
    login_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable(
            (By.ID, "login")
        )
    )
 
    username.clear()
    username.send_keys("admin")
 
    password.clear()
    password.send_keys("admin123")
 
    login_button.click()
 
    print("Login action completed")
 
finally:
    driver.quit()

55. Web Element Operations with Multiple Products

products = driver.find_elements(

    By.CSS_SELECTOR,
    ".product-card"
)
 
for product in products:
    name = product.find_element(
        By.CSS_SELECTOR,
        ".product-name"
    )
 
    price = product.find_element(
        By.CSS_SELECTOR,
        ".product-price"
    )
 
    print("Product:", name.text)
    print("Price:", price.text)

This demonstrates parent-child element operations and Python iteration together.

56. Web Element Operations with a Table

rows = driver.find_elements(

    By.CSS_SELECTOR,
    "table tbody tr"
)
 
for row in rows:
    cells = row.find_elements(By.TAG_NAME, "td")
 
    values = [cell.text for cell in cells]
 
    print(values)

This technique is useful for validating tabular data displayed in web applications.

57. Web Element Operations with Navigation

link = driver.find_element(

    By.LINK_TEXT,
    "Products"
)
 
link.click()
 
print("Current URL:", driver.current_url)
print("Page Title:", driver.title)

58. Web Element Operations with Attributes

button = driver.find_element(By.ID, "login")

 
print("Text:", button.text)
print("ID:", button.get_attribute("id"))
print("Class:", button.get_attribute("class"))
print("Type:", button.get_attribute("type"))
print("Enabled:", button.is_enabled())
print("Displayed:", button.is_displayed())

59. Web Element Operations with Page Validation

message = driver.find_element(By.ID, "success-message")

 
assert message.is_displayed()
assert "Success" in message.text
 
print("Success message validated")

Combining WebElement state checks with Python assertions is useful for functional validation.

60. Common Web Element Operations

61. Best Practices for Web Element Operations

• Use stable and meaningful locators.
• Prefer unique IDs when reliable IDs are available.
• Use CSS Selectors or XPath carefully when IDs are not suitable.
• Wait for dynamic elements before interacting with them.
• Prefer explicit waits over unnecessary hard-coded delays.
• Check element state when the application behavior requires it.
• Use clear() before entering replacement text when appropriate.
• Use is_selected() before changing checkbox or radio-button state when necessary.
• Use get_attribute() when validating attributes or dynamic values.
• Re-locate elements after DOM changes when stale references can occur.
• Avoid unnecessary JavaScript clicks.
• Keep element locators organized in Page Object classes for larger frameworks.
• Use meaningful variable names such as username_field and login_button.
• Keep test data separate from element interaction logic.
• Capture screenshots when diagnosing important failures.

62. Common Mistakes in Web Element Operations

63. Practical Project: Login Form Automation

Create a Selenium script that performs the following WebElement operations:

1. Open a login page.
2. Locate the username field.
3. Clear the username field.
4. Enter a username.
5. Locate the password field.
6. Enter a password.
7. Locate the Remember Me checkbox.
8. Check its current state.
9. Select it if required.
10. Locate the login button.
11. Verify that the button is enabled.
12. Click the login button.
13. Validate the success message.
14. Capture a screenshot if required.
15. Quit the browser.

64. Practical Project: E-Commerce Product Validation

products = driver.find_elements(

    By.CSS_SELECTOR,
    ".product-card"
)
 
for product in products:
    name = product.find_element(
        By.CSS_SELECTOR,
        ".product-name"
    )
 
    price = product.find_element(
        By.CSS_SELECTOR,
        ".product-price"
    )
 
    print("Name:", name.text)
    print("Price:", price.text)

This type of operation can be expanded to validate product names, prices, availability, ratings, and Add to Cart buttons.

65. Practical Project: Checkbox Validation

terms = driver.find_element(

    By.ID,
    "terms"
)
 
if not terms.is_selected():
    terms.click()
 
assert terms.is_selected()
 
print("Terms checkbox selected")

66. Practical Project: Form Field Validation

email = driver.find_element(By.ID, "email")

 
email.clear()
email.send_keys("[email protected]")
 
entered_email = email.get_attribute("value")
 
assert entered_email == "[email protected]"
 
print("Email value validated")

67. Web Element Operations in Page Object Model

In larger Selenium projects, WebElement operations are often organized inside Page Object classes. This separates page interaction logic from test logic.

from selenium.webdriver.common.by import By

 
class LoginPage:
    USERNAME = (By.ID, "username")
    PASSWORD = (By.ID, "password")
    LOGIN_BUTTON = (By.ID, "login")
 
    def __init__(self, driver):
        self.driver = driver
 
    def enter_username(self, username):
        element = self.driver.find_element(*self.USERNAME)
        element.clear()
        element.send_keys(username)
 
    def enter_password(self, password):
        element = self.driver.find_element(*self.PASSWORD)
        element.clear()
        element.send_keys(password)
 
    def click_login(self):
        self.driver.find_element(
            *self.LOGIN_BUTTON
        ).click()

68. Web Element Operation Execution Flow

Test Case

    |
    v
Open Browser
    |
    v
Navigate to Page
    |
    v
Locate Web Element
    |
    v
Verify Element State
    |
    v
Perform Operation
    |
    +----> Click
    |
    +----> Send Keys
    |
    +----> Clear
    |
    +----> Read Text
    |
    +----> Read Attribute
    |
    +----> Check State
    |
    v
Validate Result
    |
    v
Continue Test
    |
    v
Quit Browser

69. Interview Questions on Web Element Operations

Q1. What is a WebElement in Selenium?

A WebElement is Selenium's representation of a web page element that has been located in the current browsing context.

Q2. What is the use of click()?

The click() method performs a click operation on an element.

Q3. What is the use of send_keys()?

send_keys() simulates typing into a keyboard-interactable element.

Q4. What is the use of clear()?

clear() clears the current value of a supported editable element.

Q5. How do you get text from a WebElement?

text = element.text

Q6. How do you get an attribute from an element?

value = element.get_attribute("href")

Q7. How do you check whether an element is visible?

element.is_displayed()

Q8. How do you check whether an element is enabled?

element.is_enabled()

Q9. How do you check whether a checkbox is selected?

element.is_selected()

Q10. What is the difference between find_element() and find_elements()?

find_element() is used to locate a single matching element, while find_elements() returns a collection of matching elements.

Q11. Can a WebElement find another WebElement?

Yes. A WebElement can be used as the search context to locate child or descendant elements.

Q12. Why can a WebElement become stale?

A WebElement reference can become stale when the DOM changes and the previously located element is no longer attached to the current page structure.

Q13. How can you handle dynamic elements?

Use stable locators and appropriate explicit waits such as visibility or clickability conditions.

Q14. What is get_attribute() used for?

It retrieves the current value of an element attribute or property.

Q15. Which operations are commonly used for form automation?

Common operations include send_keys(), clear(), click(), is_selected(), is_enabled(), and validation through text or attributes.

70. Quick Revision Table

71. Final Summary

Web Element Operations are the core interactions used in Selenium automation. After locating a web element, Selenium allows Python programs to click it, enter text, clear fields, read visible text, retrieve attributes and properties, check visibility and enabled state, verify selections, find child elements, and perform other browser interactions.

The most important WebElement operations to learn are click(), send_keys(), clear(), text, get_attribute(), get_dom_attribute(), get_property(), is_displayed(), is_enabled(), is_selected(), tag_name, find_element(), and find_elements().

Reliable Selenium automation combines these operations with stable locators, explicit waits, appropriate exception handling, reusable Page Object classes, meaningful validations, and proper browser cleanup. Selenium's official documentation describes these element interaction and information APIs as core WebDriver functionality. :contentReference[oaicite:16]{index=16}

72. Course Resources

Selenium Training: Selenium Training Course

Register for Course Demo: Register for Selenium Course Demo

Official Selenium Documentation: Selenium Documentation

WebElement Python API: Selenium Python WebElement API Reference